const express = require('express');
const { body, validationResult } = require('express-validator');
const { Op } = require('sequelize');
const { asyncHandler } = require('../middleware/errorHandler');
const { success, error, checkEmail, checkPass, encryptPassword, verifyPassword, generateToken, random } = require('../utils/common');
const User = require('../models/User');
const logger = require('../utils/logger');

const router = express.Router();

/**
 * 用户注册
 */
router.post('/register', [
  body('username').isLength({ min: 3, max: 20 }).withMessage('用户名长度必须在3-20位之间'),
  body('password').isLength({ min: 6, max: 20 }).withMessage('密码长度必须在6-20位之间'),
  body('email').optional().isEmail().withMessage('邮箱格式不正确'),
  body('role').optional().isIn(['student', 'teacher']).withMessage('角色不正确')
], asyncHandler(async (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json(error(errors.array()[0].msg));
  }

  const { username, password, email, nickname, role = 'student' } = req.body;

  // 检查用户名是否已存在
  const existingUser = await User.findOne({
    where: {
      [Op.or]: [
        { username },
        ...(email ? [{ email }] : [])
      ]
    }
  });

  if (existingUser) {
    return res.status(400).json(error('用户名或邮箱已存在'));
  }

  // 验证密码强度
  // if (!checkPass(password)) {
  //   return res.status(400).json(error('密码必须包含字母和数字'));
  // }

  // 加密密码
  const hashedPassword = await encryptPassword(password);

  // 创建用户
  const user = await User.create({
    username,
    password: hashedPassword,
    email,
    nickname: nickname || username,
    role
  });

  // 生成token
  const token = generateToken({
    id: user.id,
    username: user.username,
    role: user.role
  });

  res.json(success({
    user: {
      id: user.id,
      username: user.username,
      nickname: user.nickname,
      email: user.email,
      role: user.role,
      avatar: user.avatar
    },
    token
  }, '注册成功'));
}));

/**
 * 用户登录
 */
router.post('/login', [
  body('username').notEmpty().withMessage('用户名不能为空'),
  body('password').notEmpty().withMessage('密码不能为空')
], asyncHandler(async (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json(error(errors.array()[0].msg));
  }

  const { username, password } = req.body;

  // 查找用户
  const user = await User.findOne({
    where: {
      [Op.or]: [
        { username },
        { email: username }
      ]
    }
  });

  if (!user) {
    return res.status(400).json(error('用户不存在'));
  }

  if (user.status !== 'active') {
    return res.status(400).json(error('账户已被禁用'));
  }

  // 验证密码
  const isValidPassword = await verifyPassword(password, user.password);
  if (!isValidPassword) {
    return res.status(400).json(error('密码错误'));
  }

  // 更新最后登录信息
  await user.update({
    last_login_at: new Date(),
    last_login_ip: req.ip
  });

  // 生成token
  const token = generateToken({
    id: user.id,
    username: user.username,
    role: user.role
  });

  res.json(success({
    user: {
      id: user.id,
      username: user.username,
      nickname: user.nickname,
      email: user.email,
      role: user.role,
      avatar: user.avatar,
      level: user.level,
      experience: user.experience,
      coin: user.coin,
      votes: user.votes
    },
    token
  }, '登录成功'));
}));

/**
 * 发送验证码
 */
router.post('/send-code', [
  body('account').notEmpty().withMessage('账号不能为空'),
  body('type').isIn(['email']).withMessage('类型不正确')
], asyncHandler(async (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json(error(errors.array()[0].msg));
  }

  const { account, type } = req.body;

  // 验证账号格式
  if (type === 'email' && !checkEmail(account)) {
    return res.status(400).json(error('邮箱格式不正确'));
  }

  // 生成验证码
  const code = random(6, true);

  // TODO: 发送验证码到邮箱或手机
  // 这里需要集成邮件服务或短信服务

  logger.info(`发送验证码: ${type} ${account} ${code}`);

  res.json(success(null, '验证码发送成功'));
}));

/**
 * 忘记密码
 */
router.post('/forgot-password', [
  body('account').notEmpty().withMessage('账号不能为空'),
  body('code').isLength({ min: 6, max: 6 }).withMessage('验证码格式不正确'),
  body('new_password').isLength({ min: 6, max: 20 }).withMessage('密码长度必须在6-20位之间')
], asyncHandler(async (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json(error(errors.array()[0].msg));
  }

  const { account, code, new_password } = req.body;

  // TODO: 验证验证码逻辑
  // 这里需要实现验证码验证逻辑

  // 查找用户
  const user = await User.findOne({
    where: {
      email: account
    }
  });

  if (!user) {
    return res.status(400).json(error('用户不存在'));
  }

  // 验证密码强度
  if (!checkPass(new_password)) {
    return res.status(400).json(error('密码必须包含字母和数字'));
  }

  // 更新密码
  const hashedPassword = await encryptPassword(new_password);
  await user.update({ password: hashedPassword });

  res.json(success(null, '密码重置成功'));
}));

/**
 * 退出登录
 */
router.post('/logout', asyncHandler(async (req, res) => {
  // 直接返回成功，不需要清理Redis
  res.json(success(null, '退出成功'));
}));

/**
 * 刷新token
 */
router.post('/refresh-token', asyncHandler(async (req, res) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  
  if (!token) {
    return res.status(401).json(error('未提供token'));
  }

  try {
    const decoded = require('jsonwebtoken').verify(token, process.env.JWT_SECRET, { ignoreExpiration: true });
    
    // 检查用户是否存在
    const user = await User.findByPk(decoded.id);
    if (!user || user.status !== 'active') {
      return res.status(401).json(error('用户不存在或已被禁用'));
    }

    // 生成新token
    const newToken = generateToken({
      id: user.id,
      username: user.username,
      role: user.role
    });

    res.json(success({ token: newToken }, 'token刷新成功'));
  } catch (err) {
    return res.status(401).json(error('token无效'));
  }
}));

module.exports = router; 